from tkinter import *
from tkinter import ttk
import datetime
from invfun import inv, inv_1
from math import sin, cos, tan, radians, degrees, floor, sqrt, acos, atan, pi
from gear import Gear,GearInit,PlanetaryGear,PlanetInit,PrintToTxt,gongfaxian,liangzhu
from huichacalc import InputEb,cx_gear,cx_fxfy,ptcx,pthc2allhc

class GearGUI_hc(object):
    def __init__(self,root):
        #
        root.title('GearGUI——回差计算') # root：主窗口
        ##
        mainframe = ttk.Frame(root,padding=(3,3,12,12))# 主框架,在内侧用padding设置边缘空隙
        ###
        frame_std = ttk.Frame(mainframe,padding=(3,3,12,12))
        frame_std.grid(column=0,row=0,columnspan=4,sticky=(N,S,E,W),pady=5,padx=5)
        label_std_alpha_deg = ttk.Label(frame_std,text='压力角(°)')
        label_std_alpha_deg.grid(column=0,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_std_alpha_deg_var = DoubleVar(value=20)
        entry_std_alpha_deg = ttk.Entry(frame_std,textvariable=self.entry_std_alpha_deg_var,width=8)
        entry_std_alpha_deg.grid(column=1,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        label_std_ha = ttk.Label(frame_std,text='齿顶高系数ha*')
        label_std_ha.grid(column=2,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_std_ha_var = DoubleVar(value=1.0)
        entry_std_ha = ttk.Entry(frame_std,textvariable=self.entry_std_ha_var,width=8)
        entry_std_ha.grid(column=3,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        label_std_c = ttk.Label(frame_std,text='顶隙系数c*')
        label_std_c.grid(column=4,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_std_c_var = DoubleVar(value=0.25)
        entry_std_c = ttk.Entry(frame_std,textvariable=self.entry_std_c_var,width=8)
        entry_std_c.grid(column=5,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        ###
        frame_1 = ttk.LabelFrame(mainframe,text='第一级(输入级)参数',padding=(3,3,12,12)) # 输入级框架
        ####
        label_1_m = ttk.Label(frame_1,text='m(模数)')
        self.entry_1_m_var = DoubleVar()
        self.entry_1_m = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_m_var)
        self.check_1_x1_var = StringVar(value='disable')
        check_1_x1 = ttk.Checkbutton(frame_1,text='中心距相等计算x1',variable=self.check_1_x1_var,onvalue='disable',offvalue='normal',command=self.checkfun_1_x1)
        label_1_sun = ttk.Label(frame_1,text='太阳轮(1)')
        label_1_planet = ttk.Label(frame_1,text='行星轮(3)')
        label_1_internal = ttk.Label(frame_1,text='内齿轮(2)')
        label_1_z = ttk.Label(frame_1,text='z(齿数)')
        self.entry_1_z1_var = DoubleVar()
        entry_1_z1 = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_z1_var)
        self.entry_1_z3_var = DoubleVar()
        entry_1_z3 = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_z3_var)
        self.entry_1_z2_var = DoubleVar()
        entry_1_z2 = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_z2_var)
        label_1_x = ttk.Label(frame_1,text='x(变位)')
        self.entry_1_x1_var = DoubleVar()
        self.entry_1_x1 = ttk.Entry(frame_1,width=8,state=self.check_1_x1_var.get(),textvariable=self.entry_1_x1_var)
        self.entry_1_x3_var = DoubleVar()
        entry_1_x3 = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_x3_var)
        self.entry_1_x2_var = DoubleVar()
        entry_1_x2 = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_x2_var)
        label_1_b = ttk.Label(frame_1,text='b(齿宽)')
        self.entry_1_b1_var = DoubleVar()
        entry_1_b1 = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_b1_var)
        self.entry_1_b3_var = DoubleVar()
        entry_1_b3 = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_b3_var)
        self.entry_1_b2_var = DoubleVar()
        entry_1_b2 = ttk.Entry(frame_1,width=8,textvariable=self.entry_1_b2_var)
        label_1_IT = ttk.Label(frame_1,text='IT(精度)')
        self.combo_1_IT1_var = IntVar(value=6)
        combo_1_IT1 = ttk.Combobox(frame_1,width=8,state='readonly',textvariable=self.combo_1_IT1_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        self.combo_1_IT3_var = IntVar(value=6)
        combo_1_IT3 = ttk.Combobox(frame_1,width=8,state='readonly',textvariable=self.combo_1_IT3_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        self.combo_1_IT2_var = IntVar(value=7)
        combo_1_IT2 = ttk.Combobox(frame_1,width=8,state='readonly',textvariable=self.combo_1_IT2_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        
        ###
        frame_2 = ttk.LabelFrame(mainframe,text='第二级参数',padding=(3,3,12,12)) # 输入级框架
        ####
        label_2_m = ttk.Label(frame_2,text='m(模数)')
        self.entry_2_m_var = DoubleVar()
        entry_2_m = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_m_var)
        self.check_2_x1_var = StringVar(value='disable')
        check_2_x1 = ttk.Checkbutton(frame_2,text='中心距相等计算x1',variable=self.check_2_x1_var,onvalue='disable',offvalue='normal',command=self.checkfun_2_x1)
        label_2_sun = ttk.Label(frame_2,text='太阳轮(1)')
        label_2_planet = ttk.Label(frame_2,text='行星轮(3)')
        label_2_internal = ttk.Label(frame_2,text='内齿轮(2)')
        label_2_z = ttk.Label(frame_2,text='z(齿数)')
        self.entry_2_z1_var = DoubleVar()
        entry_2_z1 = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_z1_var)
        self.entry_2_z3_var = DoubleVar()
        entry_2_z3 = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_z3_var)
        self.entry_2_z2_var = DoubleVar()
        entry_2_z2 = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_z2_var)
        label_2_x = ttk.Label(frame_2,text='x(变位)')
        self.entry_2_x1_var = DoubleVar()
        self.entry_2_x1 = ttk.Entry(frame_2,width=8,state=self.check_2_x1_var.get(),textvariable=self.entry_2_x1_var)
        self.entry_2_x3_var = DoubleVar()
        entry_2_x3 = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_x3_var)
        self.entry_2_x2_var = DoubleVar()
        entry_2_x2 = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_x2_var)
        label_2_b = ttk.Label(frame_2,text='b(齿宽)')
        self.entry_2_b1_var = DoubleVar()
        entry_2_b1 = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_b1_var)
        self.entry_2_b3_var = DoubleVar()
        entry_2_b3 = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_b3_var)
        self.entry_2_b2_var = DoubleVar()
        entry_2_b2 = ttk.Entry(frame_2,width=8,textvariable=self.entry_2_b2_var)
        label_2_IT = ttk.Label(frame_2,text='IT(精度)')
        self.combo_2_IT1_var = IntVar(value=6)
        combo_2_IT1 = ttk.Combobox(frame_2,width=8,state='readonly',textvariable=self.combo_2_IT1_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        self.combo_2_IT3_var = IntVar(value=6)
        combo_2_IT3 = ttk.Combobox(frame_2,width=8,state='readonly',textvariable=self.combo_2_IT3_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        self.combo_2_IT2_var = IntVar(value=7)
        combo_2_IT2 = ttk.Combobox(frame_2,width=8,state='readonly',textvariable=self.combo_2_IT2_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        
        
        ###
        self.check_3_var = StringVar(value='normal')
        check_3 = ttk.Checkbutton(mainframe,text='第三级',variable=self.check_3_var,onvalue='normal',offvalue='disable',command=self.checkfun_3)
        
        ###
        frame_3 = ttk.LabelFrame(mainframe,text='第三级参数',padding=(3,3,12,12)) # 输入级框架
        ####
        self.label_3_m = ttk.Label(frame_3,text='m(模数)')
        self.entry_3_m_var = DoubleVar()
        self.entry_3_m = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_m_var)
        self.check_3_x1_var = StringVar(value='disable')
        self.check_3_x1 = ttk.Checkbutton(frame_3,text='中心距相等计算x1',variable=self.check_3_x1_var,onvalue='disable',offvalue='normal',command=self.checkfun_3_x1)
        self.label_3_sun = ttk.Label(frame_3,text='太阳轮(1)')
        self.label_3_planet = ttk.Label(frame_3,text='行星轮(3)')
        self.label_3_internal = ttk.Label(frame_3,text='内齿轮(2)')
        self.label_3_z = ttk.Label(frame_3,text='z(齿数)')
        self.entry_3_z1_var = DoubleVar()
        self.entry_3_z1 = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_z1_var)
        self.entry_3_z3_var = DoubleVar()
        self.entry_3_z3 = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_z3_var)
        self.entry_3_z2_var = DoubleVar()
        self.entry_3_z2 = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_z2_var)
        self.label_3_x = ttk.Label(frame_3,text='x(变位)')
        self.entry_3_x1_var = DoubleVar()
        self.entry_3_x1 = ttk.Entry(frame_3,width=8,state=self.check_3_x1_var.get(),textvariable=self.entry_3_x1_var)
        self.entry_3_x3_var = DoubleVar()
        self.entry_3_x3 = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_x3_var)
        self.entry_3_x2_var = DoubleVar()
        self.entry_3_x2 = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_x2_var)
        self.label_3_b = ttk.Label(frame_3,text='b(齿宽)')
        self.entry_3_b1_var = DoubleVar()
        self.entry_3_b1 = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_b1_var)
        self.entry_3_b3_var = DoubleVar()
        self.entry_3_b3 = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_b3_var)
        self.entry_3_b2_var = DoubleVar()
        self.entry_3_b2 = ttk.Entry(frame_3,width=8,textvariable=self.entry_3_b2_var)
        self.label_3_IT = ttk.Label(frame_3,text='IT(精度)')
        self.combo_3_IT1_var = IntVar(value=6)
        self.combo_3_IT1 = ttk.Combobox(frame_3,width=8,state='readonly',textvariable=self.combo_3_IT1_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        self.combo_3_IT3_var = IntVar(value=6)
        self.combo_3_IT3 = ttk.Combobox(frame_3,width=8,state='readonly',textvariable=self.combo_3_IT3_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        self.combo_3_IT2_var = IntVar(value=7)
        self.combo_3_IT2 = ttk.Combobox(frame_3,width=8,state='readonly',textvariable=self.combo_3_IT2_var,values=(0,1,2,3,4,5,6,7,8,9,10,11,12))
        
        # 放置齿轮数据部件
        ##
        mainframe.grid(column=0,row=0,sticky=(N,S,E,W),pady=5,padx=5) # 放置主框架，在root主窗口中的第0行第0列，sticky拉伸、贴合至四周

        
        ###
        frame_1.grid(column=0,row=1,columnspan=2,sticky=(N,S,E,W),pady=5,padx=5)
        ####
        label_1_m.grid(column=0,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_1_m.grid(column=1,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        check_1_x1.grid(column=2,row=0,columnspan=2,sticky=(N,S,E,W),pady=3,padx=3)
        label_1_sun.grid(column=1,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        label_1_planet.grid(column=2,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        label_1_internal.grid(column=3,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        label_1_z.grid(column=0,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        entry_1_z1.grid(column=1,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        entry_1_z3.grid(column=2,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        entry_1_z2.grid(column=3,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        label_1_x.grid(column=0,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_1_x1.grid(column=1,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        entry_1_x3.grid(column=2,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        entry_1_x2.grid(column=3,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        label_1_b.grid(column=0,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        entry_1_b1.grid(column=1,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        entry_1_b3.grid(column=2,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        entry_1_b2.grid(column=3,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        label_1_IT.grid(column=0,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        combo_1_IT1.grid(column=1,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        combo_1_IT3.grid(column=2,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        combo_1_IT2.grid(column=3,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        
        ###
        frame_2.grid(column=2,row=1,columnspan=2,sticky=(N,S,E,W),pady=5,padx=5)
        ####
        label_2_m.grid(column=0,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_m.grid(column=1,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        check_2_x1.grid(column=2,row=0,columnspan=2,sticky=(N,S,E,W),pady=3,padx=3)
        label_2_sun.grid(column=1,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        label_2_planet.grid(column=2,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        label_2_internal.grid(column=3,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        label_2_z.grid(column=0,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_z1.grid(column=1,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_z3.grid(column=2,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_z2.grid(column=3,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        label_2_x.grid(column=0,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_2_x1.grid(column=1,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_x3.grid(column=2,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_x2.grid(column=3,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        label_2_b.grid(column=0,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_b1.grid(column=1,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_b3.grid(column=2,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        entry_2_b2.grid(column=3,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        label_2_IT.grid(column=0,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        combo_2_IT1.grid(column=1,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        combo_2_IT3.grid(column=2,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        combo_2_IT2.grid(column=3,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        
        ###
        check_3.grid(column=4,row=0,sticky=(N,S,E,W),pady=5,padx=5)
        
        ###
        frame_3.grid(column=4,row=1,columnspan=2,sticky=(N,S,E,W),pady=5,padx=5)
        ####
        self.label_3_m.grid(column=0,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_m.grid(column=1,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        self.check_3_x1.grid(column=2,row=0,columnspan=2,sticky=(N,S,E,W),pady=3,padx=3)
        self.label_3_sun.grid(column=1,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        self.label_3_planet.grid(column=2,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        self.label_3_internal.grid(column=3,row=1,sticky=(N,S,E,W),pady=3,padx=3)
        self.label_3_z.grid(column=0,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_z1.grid(column=1,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_z3.grid(column=2,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_z2.grid(column=3,row=2,sticky=(N,S,E,W),pady=3,padx=3)
        self.label_3_x.grid(column=0,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_x1.grid(column=1,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_x3.grid(column=2,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_x2.grid(column=3,row=3,sticky=(N,S,E,W),pady=3,padx=3)
        self.label_3_b.grid(column=0,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_b1.grid(column=1,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_b3.grid(column=2,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        self.entry_3_b2.grid(column=3,row=4,sticky=(N,S,E,W),pady=3,padx=3)
        self.label_3_IT.grid(column=0,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        self.combo_3_IT1.grid(column=1,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        self.combo_3_IT3.grid(column=2,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        self.combo_3_IT2.grid(column=3,row=5,sticky=(N,S,E,W),pady=3,padx=3)
        

        #公法线量柱球选择和输入
        #### 1
        self.radio_1_EbEy1_var = StringVar(value='Eb')
        self.radio_1_EbEy3_var = StringVar(value='Eb')
        self.radio_1_EbEy2_var = StringVar(value='Ey')
        self.radio_1_Eb1 = ttk.Radiobutton(frame_1,text='公法线',variable=self.radio_1_EbEy1_var,value='Eb',command=self.radiofun_1_EbEy)
        self.radio_1_Eb3 = ttk.Radiobutton(frame_1,text='公法线',variable=self.radio_1_EbEy3_var,value='Eb',command=self.radiofun_1_EbEy)
        self.radio_1_Eb2 = ttk.Radiobutton(frame_1,text='公法线',variable=self.radio_1_EbEy2_var,value='Eb',command=self.radiofun_1_EbEy)
        self.radio_1_Eb1.grid(column=1,row=6,sticky=(N,S,W),pady=3,padx=3)
        self.radio_1_Eb3.grid(column=2,row=6,sticky=(N,S,W),pady=3,padx=3)
        self.radio_1_Eb2.grid(column=3,row=6,sticky=(N,S,W),pady=3,padx=3)
        
        self.radio_1_Ey1 = ttk.Radiobutton(frame_1,text='量柱球',variable=self.radio_1_EbEy1_var,value='Ey',command=self.radiofun_1_EbEy)
        self.radio_1_Ey3 = ttk.Radiobutton(frame_1,text='量柱球',variable=self.radio_1_EbEy3_var,value='Ey',command=self.radiofun_1_EbEy)
        self.radio_1_Ey2 = ttk.Radiobutton(frame_1,text='量柱球',variable=self.radio_1_EbEy2_var,value='Ey',command=self.radiofun_1_EbEy)
        self.radio_1_Ey1.grid(column=1,row=7,sticky=(N,S,W),pady=3,padx=3)
        self.radio_1_Ey3.grid(column=2,row=7,sticky=(N,S,W),pady=3,padx=3)
        self.radio_1_Ey2.grid(column=3,row=7,sticky=(N,S,W),pady=3,padx=3)
        
        [self.Eb_1_var1,self.Ey_1_var1] = ['normal','disable'] if self.radio_1_EbEy1_var.get()=='Eb' else ['disable','normal']
        [self.Eb_1_var3,self.Ey_1_var3] = ['normal','disable'] if self.radio_1_EbEy3_var.get()=='Eb' else ['disable','normal']
        [self.Eb_1_var2,self.Ey_1_var2] = ['normal','disable'] if self.radio_1_EbEy2_var.get()=='Eb' else ['disable','normal']
        
        self.label_1_Eb = ttk.Label(frame_1,text='公称长度')
        self.label_1_Eb.grid(column=0,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Eb1_var = DoubleVar()
        entry_1_Eb1 = ttk.Entry(frame_1,textvariable=self.entry_1_Eb1_var,width=8,state='disable')
        entry_1_Eb1.grid(column=1,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Eb3_var = DoubleVar()
        entry_1_Eb3 = ttk.Entry(frame_1,textvariable=self.entry_1_Eb3_var,width=8,state='disable')
        entry_1_Eb3.grid(column=2,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Eb2_var = DoubleVar()
        entry_1_Eb2 = ttk.Entry(frame_1,textvariable=self.entry_1_Eb2_var,width=8,state='disable')
        entry_1_Eb2.grid(column=3,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        
        self.label_1_Ebs = ttk.Label(frame_1,text='上偏差s(um)')
        self.label_1_Ebs.grid(column=0,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.label_1_Ebi = ttk.Label(frame_1,text='下偏差i(um)')
        self.label_1_Ebi.grid(column=0,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        ####跨距/量柱直径设置
        self.label_1_Eb_K = ttk.Label(frame_1,text='公法线跨齿数')
        self.label_1_Eb_K.grid(column=0,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.label_1_Ey_Dm = ttk.Label(frame_1,text='量柱直径(mm)')
        self.label_1_Ey_Dm.grid(column=0,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ebs1_var = DoubleVar() # 太阳轮上偏差
        self.entry_1_Ebs1 = ttk.Entry(frame_1,textvariable=self.entry_1_Ebs1_var,width=8)
        self.entry_1_Ebs1.grid(column=1,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ebi1_var = DoubleVar() # 太阳轮下偏差
        self.entry_1_Ebi1 = ttk.Entry(frame_1,textvariable=self.entry_1_Ebi1_var,width=8)
        self.entry_1_Ebi1.grid(column=1,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Eb_K1_var = IntVar() # 太阳轮跨齿数
        self.entry_1_Eb_K1 = ttk.Entry(frame_1,textvariable=self.entry_1_Eb_K1_var,width=8,state=self.Eb_1_var1)
        self.entry_1_Eb_K1.grid(column=1,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ey_Dm1_var = DoubleVar() # 太阳轮量柱直径
        self.entry_1_Ey_Dm1 = ttk.Entry(frame_1,textvariable=self.entry_1_Ey_Dm1_var,width=8,state=self.Ey_1_var1)
        self.entry_1_Ey_Dm1.grid(column=1,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ebs3_var = DoubleVar() # 行星轮上偏差
        self.entry_1_Ebs3 = ttk.Entry(frame_1,textvariable=self.entry_1_Ebs3_var,width=8)
        self.entry_1_Ebs3.grid(column=2,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ebi3_var = DoubleVar() # 行星轮下偏差
        self.entry_1_Ebi3 = ttk.Entry(frame_1,textvariable=self.entry_1_Ebi3_var,width=8)
        self.entry_1_Ebi3.grid(column=2,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Eb_K3_var = IntVar() # 行星轮跨齿数
        self.entry_1_Eb_K3 = ttk.Entry(frame_1,textvariable=self.entry_1_Eb_K3_var,width=8,state=self.Eb_1_var3)
        self.entry_1_Eb_K3.grid(column=2,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ey_Dm3_var = DoubleVar() # 行星轮量柱直径
        self.entry_1_Ey_Dm3 = ttk.Entry(frame_1,textvariable=self.entry_1_Ey_Dm3_var,width=8,state=self.Ey_1_var3)
        self.entry_1_Ey_Dm3.grid(column=2,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ebs2_var = DoubleVar() # 内齿轮上偏差
        self.entry_1_Ebs2 = ttk.Entry(frame_1,textvariable=self.entry_1_Ebs2_var,width=8)
        self.entry_1_Ebs2.grid(column=3,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ebi2_var = DoubleVar() # 内齿轮下偏差
        self.entry_1_Ebi2 = ttk.Entry(frame_1,textvariable=self.entry_1_Ebi2_var,width=8)
        self.entry_1_Ebi2.grid(column=3,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Eb_K2_var = IntVar() # 内齿轮跨齿数
        self.entry_1_Eb_K2 = ttk.Entry(frame_1,textvariable=self.entry_1_Eb_K2_var,width=8,state=self.Eb_1_var2)
        self.entry_1_Eb_K2.grid(column=3,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_1_Ey_Dm2_var = DoubleVar() # 内齿轮量柱直径
        self.entry_1_Ey_Dm2 = ttk.Entry(frame_1,textvariable=self.entry_1_Ey_Dm2_var,width=8,state=self.Ey_1_var2)
        self.entry_1_Ey_Dm2.grid(column=3,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        
        
        
        #### 2
        self.radio_2_EbEy1_var = StringVar(value='Eb')
        self.radio_2_EbEy3_var = StringVar(value='Eb')
        self.radio_2_EbEy2_var = StringVar(value='Ey')
        self.radio_2_Eb1 = ttk.Radiobutton(frame_2,text='公法线',variable=self.radio_2_EbEy1_var,value='Eb',command=self.radiofun_2_EbEy)
        self.radio_2_Eb3 = ttk.Radiobutton(frame_2,text='公法线',variable=self.radio_2_EbEy3_var,value='Eb',command=self.radiofun_2_EbEy)
        self.radio_2_Eb2 = ttk.Radiobutton(frame_2,text='公法线',variable=self.radio_2_EbEy2_var,value='Eb',command=self.radiofun_2_EbEy)
        self.radio_2_Eb1.grid(column=1,row=6,sticky=(N,S,W),pady=3,padx=3)
        self.radio_2_Eb3.grid(column=2,row=6,sticky=(N,S,W),pady=3,padx=3)
        self.radio_2_Eb2.grid(column=3,row=6,sticky=(N,S,W),pady=3,padx=3)
        
        self.radio_2_Ey1 = ttk.Radiobutton(frame_2,text='量柱球',variable=self.radio_2_EbEy1_var,value='Ey',command=self.radiofun_2_EbEy)
        self.radio_2_Ey3 = ttk.Radiobutton(frame_2,text='量柱球',variable=self.radio_2_EbEy3_var,value='Ey',command=self.radiofun_2_EbEy)
        self.radio_2_Ey2 = ttk.Radiobutton(frame_2,text='量柱球',variable=self.radio_2_EbEy2_var,value='Ey',command=self.radiofun_2_EbEy)
        self.radio_2_Ey1.grid(column=1,row=7,sticky=(N,S,W),pady=3,padx=3)
        self.radio_2_Ey3.grid(column=2,row=7,sticky=(N,S,W),pady=3,padx=3)
        self.radio_2_Ey2.grid(column=3,row=7,sticky=(N,S,W),pady=3,padx=3)
        
        [self.Eb_2_var1,self.Ey_2_var1] = ['normal','disable'] if self.radio_2_EbEy1_var.get()=='Eb' else ['disable','normal']
        [self.Eb_2_var3,self.Ey_2_var3] = ['normal','disable'] if self.radio_2_EbEy3_var.get()=='Eb' else ['disable','normal']
        [self.Eb_2_var2,self.Ey_2_var2] = ['normal','disable'] if self.radio_2_EbEy2_var.get()=='Eb' else ['disable','normal']
        
        self.label_2_Eb = ttk.Label(frame_2,text='公称长度')
        self.label_2_Eb.grid(column=0,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Eb1_var = DoubleVar()
        entry_2_Eb1 = ttk.Entry(frame_2,textvariable=self.entry_2_Eb1_var,width=8,state='disable')
        entry_2_Eb1.grid(column=1,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Eb3_var = DoubleVar()
        entry_2_Eb3 = ttk.Entry(frame_2,textvariable=self.entry_2_Eb3_var,width=8,state='disable')
        entry_2_Eb3.grid(column=2,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Eb2_var = DoubleVar()
        entry_2_Eb2 = ttk.Entry(frame_2,textvariable=self.entry_2_Eb2_var,width=8,state='disable')
        entry_2_Eb2.grid(column=3,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        
        self.label_2_Ebs = ttk.Label(frame_2,text='上偏差s(um)')
        self.label_2_Ebs.grid(column=0,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.label_2_Ebi = ttk.Label(frame_2,text='下偏差i(um)')
        self.label_2_Ebi.grid(column=0,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        ####跨距/量柱直径设置
        self.label_2_Eb_K = ttk.Label(frame_2,text='公法线跨齿数')
        self.label_2_Eb_K.grid(column=0,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.label_2_Ey_Dm = ttk.Label(frame_2,text='量柱直径(mm)')
        self.label_2_Ey_Dm.grid(column=0,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ebs1_var = DoubleVar() # 太阳轮上偏差
        self.entry_2_Ebs1 = ttk.Entry(frame_2,textvariable=self.entry_2_Ebs1_var,width=8)
        self.entry_2_Ebs1.grid(column=1,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ebi1_var = DoubleVar() # 太阳轮下偏差
        self.entry_2_Ebi1 = ttk.Entry(frame_2,textvariable=self.entry_2_Ebi1_var,width=8)
        self.entry_2_Ebi1.grid(column=1,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Eb_K1_var = IntVar() # 太阳轮跨齿数
        self.entry_2_Eb_K1 = ttk.Entry(frame_2,textvariable=self.entry_2_Eb_K1_var,width=8,state=self.Eb_2_var1)
        self.entry_2_Eb_K1.grid(column=1,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ey_Dm1_var = DoubleVar() # 太阳轮量柱直径
        self.entry_2_Ey_Dm1 = ttk.Entry(frame_2,textvariable=self.entry_2_Ey_Dm1_var,width=8,state=self.Ey_2_var1)
        self.entry_2_Ey_Dm1.grid(column=1,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ebs3_var = DoubleVar() # 行星轮上偏差
        self.entry_2_Ebs3 = ttk.Entry(frame_2,textvariable=self.entry_2_Ebs3_var,width=8)
        self.entry_2_Ebs3.grid(column=2,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ebi3_var = DoubleVar() # 行星轮下偏差
        self.entry_2_Ebi3 = ttk.Entry(frame_2,textvariable=self.entry_2_Ebi3_var,width=8)
        self.entry_2_Ebi3.grid(column=2,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Eb_K3_var = IntVar() # 行星轮跨齿数
        self.entry_2_Eb_K3 = ttk.Entry(frame_2,textvariable=self.entry_2_Eb_K3_var,width=8,state=self.Eb_2_var3)
        self.entry_2_Eb_K3.grid(column=2,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ey_Dm3_var = DoubleVar() # 行星轮量柱直径
        self.entry_2_Ey_Dm3 = ttk.Entry(frame_2,textvariable=self.entry_2_Ey_Dm3_var,width=8,state=self.Ey_2_var3)
        self.entry_2_Ey_Dm3.grid(column=2,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ebs2_var = DoubleVar() # 内齿轮上偏差
        self.entry_2_Ebs2 = ttk.Entry(frame_2,textvariable=self.entry_2_Ebs2_var,width=8)
        self.entry_2_Ebs2.grid(column=3,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ebi2_var = DoubleVar() # 内齿轮下偏差
        self.entry_2_Ebi2 = ttk.Entry(frame_2,textvariable=self.entry_2_Ebi2_var,width=8)
        self.entry_2_Ebi2.grid(column=3,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Eb_K2_var = IntVar() # 内齿轮跨齿数
        self.entry_2_Eb_K2 = ttk.Entry(frame_2,textvariable=self.entry_2_Eb_K2_var,width=8,state=self.Eb_2_var2)
        self.entry_2_Eb_K2.grid(column=3,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_2_Ey_Dm2_var = DoubleVar() # 内齿轮量柱直径
        self.entry_2_Ey_Dm2 = ttk.Entry(frame_2,textvariable=self.entry_2_Ey_Dm2_var,width=8,state=self.Ey_2_var2)
        self.entry_2_Ey_Dm2.grid(column=3,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        
        
        #### 3
        self.radio_3_EbEy1_var = StringVar(value='Eb')
        self.radio_3_EbEy3_var = StringVar(value='Eb')
        self.radio_3_EbEy2_var = StringVar(value='Ey')
        self.radio_3_Eb1 = ttk.Radiobutton(frame_3,text='公法线',variable=self.radio_3_EbEy1_var,value='Eb',command=self.radiofun_3_EbEy)
        self.radio_3_Eb3 = ttk.Radiobutton(frame_3,text='公法线',variable=self.radio_3_EbEy3_var,value='Eb',command=self.radiofun_3_EbEy)
        self.radio_3_Eb2 = ttk.Radiobutton(frame_3,text='公法线',variable=self.radio_3_EbEy2_var,value='Eb',command=self.radiofun_3_EbEy)
        self.radio_3_Eb1.grid(column=1,row=6,sticky=(N,S,W),pady=3,padx=3)
        self.radio_3_Eb3.grid(column=2,row=6,sticky=(N,S,W),pady=3,padx=3)
        self.radio_3_Eb2.grid(column=3,row=6,sticky=(N,S,W),pady=3,padx=3)
        
        self.radio_3_Ey1 = ttk.Radiobutton(frame_3,text='量柱球',variable=self.radio_3_EbEy1_var,value='Ey',command=self.radiofun_3_EbEy)
        self.radio_3_Ey3 = ttk.Radiobutton(frame_3,text='量柱球',variable=self.radio_3_EbEy3_var,value='Ey',command=self.radiofun_3_EbEy)
        self.radio_3_Ey2 = ttk.Radiobutton(frame_3,text='量柱球',variable=self.radio_3_EbEy2_var,value='Ey',command=self.radiofun_3_EbEy)
        self.radio_3_Ey1.grid(column=1,row=7,sticky=(N,S,W),pady=3,padx=3)
        self.radio_3_Ey3.grid(column=2,row=7,sticky=(N,S,W),pady=3,padx=3)
        self.radio_3_Ey2.grid(column=3,row=7,sticky=(N,S,W),pady=3,padx=3)
        
        [self.Eb_3_var1,self.Ey_3_var1] = ['normal','disable'] if self.radio_3_EbEy1_var.get()=='Eb' else ['disable','normal']
        [self.Eb_3_var3,self.Ey_3_var3] = ['normal','disable'] if self.radio_3_EbEy3_var.get()=='Eb' else ['disable','normal']
        [self.Eb_3_var2,self.Ey_3_var2] = ['normal','disable'] if self.radio_3_EbEy2_var.get()=='Eb' else ['disable','normal']
        
        self.label_3_Eb = ttk.Label(frame_3,text='公称长度')
        self.label_3_Eb.grid(column=0,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Eb1_var = DoubleVar()
        entry_3_Eb1 = ttk.Entry(frame_3,textvariable=self.entry_3_Eb1_var,width=8,state='disable')
        entry_3_Eb1.grid(column=1,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Eb3_var = DoubleVar()
        entry_3_Eb3 = ttk.Entry(frame_3,textvariable=self.entry_3_Eb3_var,width=8,state='disable')
        entry_3_Eb3.grid(column=2,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Eb2_var = DoubleVar()
        entry_3_Eb2 = ttk.Entry(frame_3,textvariable=self.entry_3_Eb2_var,width=8,state='disable')
        entry_3_Eb2.grid(column=3,row=8,sticky=(N,S,W,E),pady=3,padx=3)
        
        self.label_3_Ebs = ttk.Label(frame_3,text='上偏差s(um)')
        self.label_3_Ebs.grid(column=0,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.label_3_Ebi = ttk.Label(frame_3,text='下偏差i(um)')
        self.label_3_Ebi.grid(column=0,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        ####跨距/量柱直径设置
        self.label_3_Eb_K = ttk.Label(frame_3,text='公法线跨齿数')
        self.label_3_Eb_K.grid(column=0,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.label_3_Ey_Dm = ttk.Label(frame_3,text='量柱直径(mm)')
        self.label_3_Ey_Dm.grid(column=0,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ebs1_var = DoubleVar() # 太阳轮上偏差
        self.entry_3_Ebs1 = ttk.Entry(frame_3,textvariable=self.entry_3_Ebs1_var,width=8)
        self.entry_3_Ebs1.grid(column=1,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ebi1_var = DoubleVar() # 太阳轮下偏差
        self.entry_3_Ebi1 = ttk.Entry(frame_3,textvariable=self.entry_3_Ebi1_var,width=8)
        self.entry_3_Ebi1.grid(column=1,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Eb_K1_var = IntVar() # 太阳轮跨齿数
        self.entry_3_Eb_K1 = ttk.Entry(frame_3,textvariable=self.entry_3_Eb_K1_var,width=8,state=self.Eb_3_var1)
        self.entry_3_Eb_K1.grid(column=1,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ey_Dm1_var = DoubleVar() # 太阳轮量柱直径
        self.entry_3_Ey_Dm1 = ttk.Entry(frame_3,textvariable=self.entry_3_Ey_Dm1_var,width=8,state=self.Ey_3_var1)
        self.entry_3_Ey_Dm1.grid(column=1,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ebs3_var = DoubleVar() # 行星轮上偏差
        self.entry_3_Ebs3 = ttk.Entry(frame_3,textvariable=self.entry_3_Ebs3_var,width=8)
        self.entry_3_Ebs3.grid(column=2,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ebi3_var = DoubleVar() # 行星轮下偏差
        self.entry_3_Ebi3 = ttk.Entry(frame_3,textvariable=self.entry_3_Ebi3_var,width=8)
        self.entry_3_Ebi3.grid(column=2,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Eb_K3_var = IntVar() # 行星轮跨齿数
        self.entry_3_Eb_K3 = ttk.Entry(frame_3,textvariable=self.entry_3_Eb_K3_var,width=8,state=self.Eb_3_var3)
        self.entry_3_Eb_K3.grid(column=2,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ey_Dm3_var = DoubleVar() # 行星轮量柱直径
        self.entry_3_Ey_Dm3 = ttk.Entry(frame_3,textvariable=self.entry_3_Ey_Dm3_var,width=8,state=self.Ey_3_var3)
        self.entry_3_Ey_Dm3.grid(column=2,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ebs2_var = DoubleVar() # 内齿轮上偏差
        self.entry_3_Ebs2 = ttk.Entry(frame_3,textvariable=self.entry_3_Ebs2_var,width=8)
        self.entry_3_Ebs2.grid(column=3,row=9,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ebi2_var = DoubleVar() # 内齿轮下偏差
        self.entry_3_Ebi2 = ttk.Entry(frame_3,textvariable=self.entry_3_Ebi2_var,width=8)
        self.entry_3_Ebi2.grid(column=3,row=10,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Eb_K2_var = IntVar() # 内齿轮跨齿数
        self.entry_3_Eb_K2 = ttk.Entry(frame_3,textvariable=self.entry_3_Eb_K2_var,width=8,state=self.Eb_3_var2)
        self.entry_3_Eb_K2.grid(column=3,row=11,sticky=(N,S,W,E),pady=3,padx=3)
        self.entry_3_Ey_Dm2_var = DoubleVar() # 内齿轮量柱直径
        self.entry_3_Ey_Dm2 = ttk.Entry(frame_3,textvariable=self.entry_3_Ey_Dm2_var,width=8,state=self.Ey_3_var2)
        self.entry_3_Ey_Dm2.grid(column=3,row=12,sticky=(N,S,W,E),pady=3,padx=3)
        
        
        
        
        
        
        
        
        
        ###公差选项
        frame_gc = ttk.LabelFrame(mainframe,text='公差检验项',padding=(3,3,12,12))
        frame_gc.grid(column=0,row=3,columnspan=3,sticky=(N,S,E,W),pady=5,padx=5)
        
        ####
        #self.check_FrFi_var = StringVar(value='normal')
        #check_FrFi = ttk.Checkbutton(frame_gc,text='启用径向公差项',variable=self.check_FrFi_var,onvalue='normal',offvalue='disable',command=self.checkfun_FrFi)
        #check_FrFi.grid(column=0,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        frame_FrFi = ttk.LabelFrame(frame_gc,text='径向公差项')
        frame_FrFi.grid(column=0,row=0,sticky=(N,S,E,W),pady=5,padx=5)
        #####
        self.radio_FrFi_var = StringVar(value='Fr')
        self.radio_Fr = ttk.Radiobutton(frame_FrFi,text='径向跳动Fr',variable=self.radio_FrFi_var,value='Fr')
        self.radio_Fi = ttk.Radiobutton(frame_FrFi,text='径向综合偏差Fi\'\'',variable=self.radio_FrFi_var,value='Fi')
        self.radio_Fr.grid(column=0,row=0,sticky=(N,S,W),pady=3,padx=3)
        self.radio_Fi.grid(column=0,row=1,sticky=(N,S,W),pady=3,padx=3)
        ####
        frame_fxfy = ttk.LabelFrame(frame_gc,text='平行度公差项')
        frame_fxfy.grid(column=1,row=0,sticky=(N,S,E,W),pady=5,padx=5)
        #####
        self.radio_fxfy_var = BooleanVar(value='True')
        self.radio_fxfy = ttk.Radiobutton(frame_fxfy,text='平行度偏差fxfy',variable=self.radio_fxfy_var,value=True)
        self.radio_fxfy.grid(column=0,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        
        ### CALC BUTTON
        frame_calc = ttk.LabelFrame(mainframe,text='计算',padding=(3,3,12,12))
        frame_calc.grid(column=3,row=3,columnspan=1,sticky=(N,S,E,W),pady=5,padx=5)
        ####
        self.button_calc_allhc = ttk.Button(frame_calc,text='总回差计算',command=self.calc)
        self.button_calc_allhc.grid(column=0,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        
        
        ### TEXT
        frame_text = ttk.Frame(mainframe,width=100)
        frame_text.grid(column=4,row=3,columnspan=2,rowspan=1,sticky=(N,S,E,W),pady=5,padx=5)
        self.text_print = Text(frame_text,height=10,width=50)
        self.text_print.grid(column=0,row=0,sticky=(N,S,E,W),pady=3,padx=3)
        text_ys = ttk.Scrollbar(frame_text, orient = 'vertical', command = self.text_print.yview)
        self.text_print['yscrollcommand'] = text_ys.set
        text_ys.grid(column=1,row=0,sticky=(N,S))
        
        
        
        # 配置行、列缩放等
        root.columnconfigure(0,weight=1)
        root.rowconfigure(0,weight=1)
        
        
        # 主窗口循环刷新
        root.mainloop()
    
    def calc(self):
        def printf(char,end='\n'):
            self.text_print.insert('end',str(char)+end)
        self.text_print.delete('1.0','end')
        printf(str(datetime.datetime.today())[0:-7])
        printf('Starting Calculating...')
        
        alpha_deg = self.entry_std_alpha_deg_var.get()
        ha_std = self.entry_std_ha_var.get()
        c_std = self.entry_std_c_var.get()
        
        
        # 获取径向公差选项
        gc_FrFi = 1 if self.radio_FrFi_var.get()=='Fr' else 0
        
        if ha_std<0 or c_std<0 or alpha_deg<=0:
            printf('标准数值输入错误')
            return
        
        ### 第一级
        m1 = self.entry_1_m_var.get()
        z1_1 = self.entry_1_z1_var.get()
        z1_3 = self.entry_1_z3_var.get()
        z1_2 = self.entry_1_z2_var.get()
        b1_1 = self.entry_1_b1_var.get()
        b1_3 = self.entry_1_b3_var.get()
        b1_2 = self.entry_1_b2_var.get()
        if m1>0 and z1_1>0 and z1_3>0 and z1_2>0 and b1_1>0 and b1_3>0 and b1_2>0:
            x1_3 = self.entry_1_x3_var.get()
            x1_2 = self.entry_1_x2_var.get()
            if self.check_1_x1_var.get() == 'normal':#自己输入x1
                x1_1 = self.entry_1_x1_var.get()
            else:#自动计算x1
                x1_1 = self.calcx1(x1_2, x1_3, z1_1, z1_3, z1_2)
                self.entry_1_x1_var.set(value=x1_1)
            it1_1 = self.combo_1_IT1_var.get()
            it1_3 = self.combo_1_IT3_var.get()
            it1_2 = self.combo_1_IT2_var.get()
            
            ptinit_1 = PlanetInit(it=(it1_1,it1_3,it1_2),b=(b1_1,b1_3,b1_2),ha_std=ha_std,c_std=c_std,alpha_deg=alpha_deg,calcW=False)#在gear类中不计算公法线长度
            self.pt1 = pt1 = PlanetaryGear(m1, z1_1, z1_3, z1_2, x1_1, x1_3, x1_2, ptinit_1)
            
            Emeasure_1 = [0,0,0]
            # 1太阳轮
            if self.radio_1_EbEy1_var.get() == 'Eb': # 行星轮选项为“公法线”
                # 检查是否给定了跨齿数
                if self.entry_1_Eb_K1_var.get() == 0: #跨齿数没给定
                    K1_1,Eb1_1=gongfaxian(pt1.m, pt1.alpha, pt1.za, pt1.xa,returnK=True) # 公法线公称长度计算
                    self.entry_1_Eb_K1_var.set(value=K1_1) # 将程序计算跨齿数结果显示在entry中
                else:#跨齿数给定
                    K1_1 = self.entry_1_Eb_K1_var.get() # 从entry中获取跨齿数
                    Eb1_1=gongfaxian(pt1.m, pt1.alpha, pt1.za, pt1.xa,K=K1_1,returnK=False)
                self.entry_1_Eb1_var.set(value=Eb1_1) # 将公法线公称长度计算结果显示在disabled entry中
                
                # 设置传入Ebin的Emeasure为1（量柱为0）
                Emeasure_1[0]=1
                
            else: # 行星轮选项为“量柱”
                # 检查是否给定了量柱直径
                if self.entry_1_Ey_Dm1_var.get() == 0: # 量柱直径未给定
                    # 可以弹出警告（量柱直径可能不是标准值）
                    _,Dm1_1,_,Ey1_1 = liangzhu(pt1.m,pt1.alpha,pt1.za,pt1.xa,types='wai',returnKDm=True)
                    self.entry_1_Ey_Dm1_var.set(value=Dm1_1)
                else:
                    Dm1_1 = self.entry_1_Ey_Dm1_var.get()
                    Ey1_1 = liangzhu(pt1.m,pt1.alpha,pt1.za,pt1.xa,types='wai',returnKDm=False,Dm=Dm1_1)
                self.entry_1_Eb1_var.set(value=Ey1_1)
                
                # 设置传入Ebin的Emeasure为0（公法线为1）
                Emeasure_1[0]=0
            
            # 获取行星轮的公法线or量柱直径上下偏差
            Es1_1 = self.entry_1_Ebs1_var.get()
            Ei1_1 = self.entry_1_Ebi1_var.get()
            
            # 3行星轮
            if self.radio_1_EbEy3_var.get() == 'Eb': # 太阳轮选项为“公法线”
                # 检查是否给定了跨齿数
                if self.entry_1_Eb_K3_var.get() == 0: #跨齿数没给定
                    K1_3,Eb1_3=gongfaxian(pt1.m, pt1.alpha, pt1.zc, pt1.xc,returnK=True) # 公法线公称长度计算
                    self.entry_1_Eb_K3_var.set(value=K1_3) # 将程序计算跨齿数结果显示在entry中
                else:#跨齿数给定
                    K1_3 = self.entry_1_Eb_K3_var.get() # 从entry中获取跨齿数
                    Eb1_3=gongfaxian(pt1.m, pt1.alpha, pt1.zc, pt1.xc,K=K1_3,returnK=False)
                self.entry_1_Eb3_var.set(value=Eb1_3) # 将公法线公称长度计算结果显示在disabled entry中
                
                # 设置传入Ebin的Emeasure为1（量柱为0）
                Emeasure_1[1]=1
                
            else: # 太阳轮选项为“量柱”
                # 检查是否给定了量柱直径
                if self.entry_1_Ey_Dm3_var.get() == 0: # 量柱直径未给定
                    # 可以弹出警告（量柱直径可能不是标准值）
                    _,Dm1_3,_,Ey1_3 = liangzhu(pt1.m,pt1.alpha,pt1.zc,pt1.xc,types='wai',returnKDm=True)
                    self.entry_1_Ey_Dm3_var.set(value=Dm1_3)
                else:
                    Dm1_3 = self.entry_1_Ey_Dm3_var.get()
                    Ey1_3 = liangzhu(pt1.m,pt1.alpha,pt1.zc,pt1.xc,types='wai',returnKDm=False,Dm=Dm1_3)
                self.entry_1_Eb3_var.set(value=Ey1_3)
                
                # 设置传入Ebin的Emeasure为0（公法线为1）
                Emeasure_1[1]=0
            
            # 获取行星轮的公法线or量柱直径上下偏差
            Es1_3 = self.entry_1_Ebs3_var.get()
            Ei1_3 = self.entry_1_Ebi3_var.get()
            
            # 2内齿轮
            if self.radio_1_EbEy2_var.get() == 'Eb': # 内齿轮选项为“公法线”
                # 可以给出警告，内齿轮不适用公法线的警告
                # 检查是否给定了跨齿数
                if self.entry_1_Eb_K2_var.get() == 0: #跨齿数没给定
                    K1_2,Eb1_2=gongfaxian(pt1.m, pt1.alpha, pt1.zb, pt1.xb,returnK=True) # 公法线公称长度计算
                    self.entry_1_Eb_K2_var.set(value=K1_2) # 将程序计算跨齿数结果显示在entry中
                else:#跨齿数给定
                    K1_2 = self.entry_1_Eb_K2_var.get() # 从entry中获取跨齿数
                    Eb1_2=gongfaxian(pt1.m, pt1.alpha, pt1.zb, pt1.xb,K=K1_2,returnK=False)
                self.entry_1_Eb2_var.set(value=Eb1_2) # 将公法线公称长度计算结果显示在disabled entry中
                
                # 设置传入Ebin的Emeasure为1（量柱为0）
                Emeasure_1[2]=1
                
            else: # 内齿轮选项为“量柱”
                # 检查是否给定了量柱直径
                if self.entry_1_Ey_Dm2_var.get() == 0: # 量柱直径未给定
                    # 可以弹出警告（量柱直径可能不是标准值）
                    _,Dm1_2,_,Ey1_2 = liangzhu(pt1.m,pt1.alpha,pt1.zb,pt1.xb,types='nei',returnKDm=True)
                    self.entry_1_Ey_Dm2_var.set(value=Dm1_2)
                else:
                    Dm1_2 = self.entry_1_Ey_Dm2_var.get()
                    Ey1_2 = liangzhu(pt1.m,pt1.alpha,pt1.zb,pt1.xb,types='nei',returnKDm=False,Dm=Dm1_2)
                self.entry_1_Eb2_var.set(value=Ey1_2)
                
                # 设置传入Ebin的Emeasure为0（公法线为1）
                Emeasure_1[2]=0
            
            # 获取内齿轮的公法线or量柱直径上下偏差
            Es1_2 = self.entry_1_Ebs1_var.get()
            Ei1_2 = self.entry_1_Ebi1_var.get()
            
            # 创建齿厚减薄控制类
            Ebin_1 = InputEb(Es1_1,Ei1_1,Es1_3,Ei1_3,Es1_2,Ei1_2,Emeasure=Emeasure_1,FrFi=gc_FrFi)
            
        else:
            printf('第一级齿轮输入数据有误')
            return

        ### 第二级
        m2 = self.entry_2_m_var.get()
        z2_1 = self.entry_2_z1_var.get()
        z2_3 = self.entry_2_z3_var.get()
        z2_2 = self.entry_2_z2_var.get()
        b2_1 = self.entry_2_b1_var.get()
        b2_3 = self.entry_2_b3_var.get()
        b2_2 = self.entry_2_b2_var.get()
        if m2>0 and z2_1>0 and z2_3>0 and z2_2>0 and b2_1>0 and b2_3>0 and b2_2>0:
            x2_3 = self.entry_2_x3_var.get()
            x2_2 = self.entry_2_x2_var.get()
            if self.check_2_x1_var.get() == 'normal':#自己输入x1
                x2_1 = self.entry_2_x1_var.get()
            else:#自动计算x1
                x2_1 = self.calcx1(x2_2, x2_3, z2_1, z2_3, z2_2)
                self.entry_2_x1_var.set(value=x2_1)
            it2_1 = self.combo_2_IT1_var.get()
            it2_3 = self.combo_2_IT3_var.get()
            it2_2 = self.combo_2_IT2_var.get()
            
            ptinit_2 = PlanetInit(it=(it2_1,it2_3,it2_2),b=(b2_1,b2_3,b2_2),ha_std=ha_std,c_std=c_std,alpha_deg=alpha_deg,calcW=False)#在gear类中不计算公法线长度
            self.pt2 = pt2 = PlanetaryGear(m2, z2_1, z2_3, z2_2, x2_1, x2_3, x2_2, ptinit_2)
            
            Emeasure_2 = [0,0,0]
            # 1太阳轮
            if self.radio_2_EbEy1_var.get() == 'Eb': # 太阳轮选项为“公法线”
                # 检查是否给定了跨齿数
                if self.entry_2_Eb_K1_var.get() == 0: #跨齿数没给定
                    K2_1,Eb2_1=gongfaxian(pt2.m, pt2.alpha, pt2.za, pt2.xa,returnK=True) # 公法线公称长度计算
                    self.entry_2_Eb_K1_var.set(value=K2_1) # 将程序计算跨齿数结果显示在entry中
                else:#跨齿数给定
                    K2_1 = self.entry_2_Eb_K1_var.get() # 从entry中获取跨齿数
                    Eb2_1=gongfaxian(pt2.m, pt2.alpha, pt2.za, pt2.xa,K=K2_1,returnK=False)
                self.entry_2_Eb1_var.set(value=Eb2_1) # 将公法线公称长度计算结果显示在disabled entry中
                
                # 设置传入Ebin的Emeasure为1（量柱为0）
                Emeasure_2[0]=1
                
            else: # 太阳轮选项为“量柱”
                # 检查是否给定了量柱直径
                if self.entry_2_Ey_Dm1_var.get() == 0: # 量柱直径未给定
                    # 可以弹出警告（量柱直径可能不是标准值）
                    _,Dm2_1,_,Ey2_1 = liangzhu(pt2.m,pt2.alpha,pt2.za,pt2.xa,types='wai',returnKDm=True)
                    self.entry_2_Ey_Dm1_var.set(value=Dm1_1)
                else:
                    Dm2_1 = self.entry_2_Ey_Dm1_var.get()
                    Ey2_1 = liangzhu(pt2.m,pt2.alpha,pt2.za,pt2.xa,types='wai',returnKDm=False,Dm=Dm2_1)
                self.entry_2_Eb1_var.set(value=Ey2_1)
                
                # 设置传入Ebin的Emeasure为0（公法线为1）
                Emeasure_2[0]=0
            
            # 获取太阳轮的公法线or量柱直径上下偏差
            Es2_1 = self.entry_2_Ebs1_var.get()
            Ei2_1 = self.entry_2_Ebi1_var.get()
            
            # 3行星轮
            if self.radio_2_EbEy3_var.get() == 'Eb': # 行星轮选项为“公法线”
                # 检查是否给定了跨齿数
                if self.entry_2_Eb_K3_var.get() == 0: #跨齿数没给定
                    K2_3,Eb2_3=gongfaxian(pt2.m, pt2.alpha, pt2.zc, pt2.xc,returnK=True) # 公法线公称长度计算
                    self.entry_2_Eb_K3_var.set(value=K2_3) # 将程序计算跨齿数结果显示在entry中
                else:#跨齿数给定
                    K2_3 = self.entry_2_Eb_K3_var.get() # 从entry中获取跨齿数
                    Eb2_3=gongfaxian(pt2.m, pt2.alpha, pt2.zc, pt2.xc,K=K2_3,returnK=False)
                self.entry_2_Eb3_var.set(value=Eb2_3) # 将公法线公称长度计算结果显示在disabled entry中
                
                # 设置传入Ebin的Emeasure为1（量柱为0）
                Emeasure_2[1]=1
                
            else: # 行星轮选项为“量柱”
                # 检查是否给定了量柱直径
                if self.entry_2_Ey_Dm3_var.get() == 0: # 量柱直径未给定
                    # 可以弹出警告（量柱直径可能不是标准值）
                    _,Dm2_3,_,Ey2_3 = liangzhu(pt2.m,pt2.alpha,pt2.zc,pt2.xc,types='wai',returnKDm=True)
                    self.entry_2_Ey_Dm3_var.set(value=Dm1_3)
                else:
                    Dm2_3 = self.entry_2_Ey_Dm3_var.get()
                    Ey2_3 = liangzhu(pt2.m,pt2.alpha,pt2.zc,pt2.xc,types='wai',returnKDm=False,Dm=Dm2_3)
                self.entry_2_Eb3_var.set(value=Ey2_3)
                
                # 设置传入Ebin的Emeasure为0（公法线为1）
                Emeasure_2[1]=0
            
            # 获取行星轮的公法线or量柱直径上下偏差
            Es2_3 = self.entry_2_Ebs3_var.get()
            Ei2_3 = self.entry_2_Ebi3_var.get()
            
            # 2内齿轮
            if self.radio_2_EbEy2_var.get() == 'Eb': # 内齿轮选项为“公法线”
                # 可以给出警告，内齿轮不适用公法线的警告
                # 检查是否给定了跨齿数
                if self.entry_2_Eb_K2_var.get() == 0: #跨齿数没给定
                    K2_2,Eb2_2=gongfaxian(pt2.m, pt2.alpha, pt2.zb, pt2.xb,returnK=True) # 公法线公称长度计算
                    self.entry_2_Eb_K2_var.set(value=K2_2) # 将程序计算跨齿数结果显示在entry中
                else:#跨齿数给定
                    K2_2 = self.entry_2_Eb_K2_var.get() # 从entry中获取跨齿数
                    Eb2_2=gongfaxian(pt2.m, pt2.alpha, pt2.zb, pt2.xb,K=K2_2,returnK=False)
                self.entry_2_Eb2_var.set(value=Eb2_2) # 将公法线公称长度计算结果显示在disabled entry中
                
                # 设置传入Ebin的Emeasure为1（量柱为0）
                Emeasure_2[2]=1
                
            else: # 内齿轮选项为“量柱”
                # 检查是否给定了量柱直径
                if self.entry_2_Ey_Dm2_var.get() == 0: # 量柱直径未给定
                    # 可以弹出警告（量柱直径可能不是标准值）
                    _,Dm2_2,_,Ey2_2 = liangzhu(pt2.m, pt2.alpha, pt2.zb, pt2.xb,types='nei',returnKDm=True)
                    self.entry_2_Ey_Dm2_var.set(value=Dm2_2)
                else:
                    Dm2_2 = self.entry_2_Ey_Dm2_var.get()
                    Ey2_2 = liangzhu(pt2.m, pt2.alpha, pt2.zb, pt2.xb,types='nei',returnKDm=False,Dm=Dm2_2)
                self.entry_2_Eb2_var.set(value=Ey2_2)
                
                # 设置传入Ebin的Emeasure为0（公法线为1）
                Emeasure_2[2]=0
            
            # 获取内齿轮的公法线or量柱直径上下偏差
            Es2_2 = self.entry_2_Ebs1_var.get()
            Ei2_2 = self.entry_2_Ebi1_var.get()
            
            # 创建齿厚减薄控制类
            Ebin_2 = InputEb(Es2_1,Ei2_1,Es2_3,Ei2_3,Es2_2,Ei2_2,Emeasure=Emeasure_2,FrFi=gc_FrFi)
        else:
            printf('第二级齿轮输入数据有误')
            return
        
        ### 第三级（先判断存不存在，多缩进一位）
        if self.check_3_var.get() == 'normal':
            m3 = self.entry_3_m_var.get()
            z3_1 = self.entry_3_z1_var.get()
            z3_3 = self.entry_3_z3_var.get()
            z3_2 = self.entry_3_z2_var.get()
            b3_1 = self.entry_3_b1_var.get()
            b3_3 = self.entry_3_b3_var.get()
            b3_2 = self.entry_3_b2_var.get()
            if m3>0 and z3_1>0 and z3_3>0 and z3_2>0 and b3_1>0 and b3_3>0 and b3_2>0:
                x3_3 = self.entry_3_x3_var.get()
                x3_2 = self.entry_3_x2_var.get()
                if self.check_3_x1_var.get() == 'normal':#自己输入x1
                    x3_1 = self.entry_3_x1_var.get()
                else:#自动计算x1
                    x3_1 = self.calcx1(x3_2, x3_3, z3_1, z3_3, z3_2)
                    self.entry_3_x1_var.set(value=x3_1)
                it3_1 = self.combo_3_IT1_var.get()
                it3_3 = self.combo_3_IT3_var.get()
                it3_2 = self.combo_3_IT2_var.get()
                
                ptinit_3 = PlanetInit(it=(it3_1,it3_3,it3_2),b=(b3_1,b3_3,b3_2),ha_std=ha_std,c_std=c_std,alpha_deg=alpha_deg,calcW=False)#在gear类中不计算公法线长度
                self.pt3 = pt3 = PlanetaryGear(m3, z3_1, z3_3, z3_2, x3_1, x3_3, x3_2, ptinit_3)
                
                Emeasure_3 = [0,0,0]
                # 1太阳轮
                if self.radio_3_EbEy1_var.get() == 'Eb': # 太阳轮选项为“公法线”
                    # 检查是否给定了跨齿数
                    if self.entry_3_Eb_K1_var.get() == 0: #跨齿数没给定
                        K3_1,Eb3_1=gongfaxian(pt3.m, pt3.alpha, pt3.za, pt3.xa,returnK=True) # 公法线公称长度计算
                        self.entry_3_Eb_K1_var.set(value=K3_1) # 将程序计算跨齿数结果显示在entry中
                    else:#跨齿数给定
                        K3_1 = self.entry_3_Eb_K1_var.get() # 从entry中获取跨齿数
                        Eb3_1=gongfaxian(pt3.m, pt3.alpha, pt3.za, pt3.xa,K=K3_1,returnK=False)
                    self.entry_3_Eb1_var.set(value=Eb3_1) # 将公法线公称长度计算结果显示在disabled entry中
                    
                    # 设置传入Ebin的Emeasure为1（量柱为0）
                    Emeasure_3[0]=1
                    
                else: # 太阳轮选项为“量柱”
                    # 检查是否给定了量柱直径
                    if self.entry_3_Ey_Dm1_var.get() == 0: # 量柱直径未给定
                        # 可以弹出警告（量柱直径可能不是标准值）
                        _,Dm3_1,_,Ey3_1 = liangzhu(pt3.m, pt3.alpha, pt3.za, pt3.xa,types='wai',returnKDm=True)
                        self.entry_3_Ey_Dm1_var.set(value=Dm3_1)
                    else:
                        Dm3_1 = self.entry_3_Ey_Dm1_var.get()
                        Ey3_1 = liangzhu(pt3.m, pt3.alpha, pt3.za, pt3.xa,types='wai',returnKDm=False,Dm=Dm3_1)
                    self.entry_3_Eb1_var.set(value=Ey3_1)
                    
                    # 设置传入Ebin的Emeasure为0（公法线为1）
                    Emeasure_3[0]=0
                
                # 获取太阳轮的公法线or量柱直径上下偏差
                Es3_1 = self.entry_3_Ebs1_var.get()
                Ei3_1 = self.entry_3_Ebi1_var.get()
                
                # 3行星轮
                if self.radio_3_EbEy3_var.get() == 'Eb': # 行星轮选项为“公法线”
                    # 检查是否给定了跨齿数
                    if self.entry_3_Eb_K3_var.get() == 0: #跨齿数没给定
                        K3_3,Eb3_3=gongfaxian(pt3.m, pt3.alpha, pt3.zc, pt3.xc,returnK=True) # 公法线公称长度计算
                        self.entry_3_Eb_K3_var.set(value=K2_3) # 将程序计算跨齿数结果显示在entry中
                    else:#跨齿数给定
                        K3_3 = self.entry_3_Eb_K3_var.get() # 从entry中获取跨齿数
                        Eb3_3=gongfaxian(pt3.m, pt3.alpha, pt3.zc, pt3.xc,K=K3_3,returnK=False)
                    self.entry_3_Eb3_var.set(value=Eb3_3) # 将公法线公称长度计算结果显示在disabled entry中
                    
                    # 设置传入Ebin的Emeasure为1（量柱为0）
                    Emeasure_3[1]=1
                    
                else: # 行星轮选项为“量柱”
                    # 检查是否给定了量柱直径
                    if self.entry_3_Ey_Dm3_var.get() == 0: # 量柱直径未给定
                        # 可以弹出警告（量柱直径可能不是标准值）
                        _,Dm3_3,_,Ey3_3 = liangzhu(pt3.m, pt3.alpha, pt3.zc, pt3.xc,types='wai',returnKDm=True)
                        self.entry_3_Ey_Dm3_var.set(value=Dm3_3)
                    else:
                        Dm3_3 = self.entry_3_Ey_Dm3_var.get()
                        Ey3_3 = liangzhu(pt3.m, pt3.alpha, pt3.zc, pt3.xc,types='wai',returnKDm=False,Dm=Dm3_3)
                    self.entry_3_Eb3_var.set(value=Ey3_3)
                    
                    # 设置传入Ebin的Emeasure为0（公法线为1）
                    Emeasure_3[1]=0
                
                # 获取行星轮的公法线or量柱直径上下偏差
                Es3_3 = self.entry_3_Ebs3_var.get()
                Ei3_3 = self.entry_3_Ebi3_var.get()
                
                # 2内齿轮
                if self.radio_3_EbEy2_var.get() == 'Eb': # 内齿轮选项为“公法线”
                    # 可以给出警告，内齿轮不适用公法线的警告
                    # 检查是否给定了跨齿数
                    if self.entry_3_Eb_K2_var.get() == 0: #跨齿数没给定
                        K3_2,Eb3_2=gongfaxian(pt3.m, pt3.alpha, pt3.zb, pt3.xb,returnK=True) # 公法线公称长度计算
                        self.entry_3_Eb_K2_var.set(value=K3_2) # 将程序计算跨齿数结果显示在entry中
                    else:#跨齿数给定
                        K3_2 = self.entry_2_Eb_K2_var.get() # 从entry中获取跨齿数
                        Eb3_2=gongfaxian(pt3.m, pt3.alpha, pt3.zb, pt3.xb,K=K3_2,returnK=False)
                    self.entry_3_Eb2_var.set(value=Eb3_2) # 将公法线公称长度计算结果显示在disabled entry中
                    
                    # 设置传入Ebin的Emeasure为1（量柱为0）
                    Emeasure_3[2]=1
                    
                else: # 内齿轮选项为“量柱”
                    # 检查是否给定了量柱直径
                    if self.entry_3_Ey_Dm2_var.get() == 0: # 量柱直径未给定
                        # 可以弹出警告（量柱直径可能不是标准值）
                        _,Dm3_2,_,Ey3_2 = liangzhu(pt3.m, pt3.alpha, pt3.zb, pt3.xb,types='nei',returnKDm=True)
                        self.entry_3_Ey_Dm2_var.set(value=Dm2_2)
                    else:
                        Dm3_2 = self.entry_3_Ey_Dm2_var.get()
                        Ey3_2 = liangzhu(pt3.m, pt3.alpha, pt3.zb, pt3.xb,types='nei',returnKDm=False,Dm=Dm3_2)
                    self.entry_3_Eb2_var.set(value=Ey3_2)
                    
                    # 设置传入Ebin的Emeasure为0（公法线为1）
                    Emeasure_3[2]=0
                
                # 获取内齿轮的公法线or量柱直径上下偏差
                Es3_2 = self.entry_3_Ebs1_var.get()
                Ei3_2 = self.entry_3_Ebi1_var.get()
                
                # 创建齿厚减薄控制类
                Ebin_3 = InputEb(Es3_1,Ei3_1,Es3_3,Ei3_3,Es3_2,Ei3_2,Emeasure=Emeasure_3,FrFi=gc_FrFi)
            else:
                printf('第三级齿轮输入数据有误')
                return
        
        else:#第三级未被激活
            printf('第三级齿轮组未激活')
                        
        
        
        
        
    
    def checkfun_1_x1(self):
        self.entry_1_x1.configure(state=self.check_1_x1_var.get())
    
    def checkfun_2_x1(self):
        self.entry_2_x1.configure(state=self.check_2_x1_var.get())
    
    def checkfun_3_x1(self):
        self.entry_3_x1.configure(state=self.check_3_x1_var.get())
    
    def checkfun_3(self):
        c3 = self.check_3_var.get()
        self.label_3_m.configure(state=c3)
        self.entry_3_m.configure(state=c3)
        self.check_3_x1.configure(state=c3)
        self.label_3_sun.configure(state=c3)
        self.label_3_planet.configure(state=c3)
        self.label_3_internal.configure(state=c3)
        self.label_3_z.configure(state=c3)
        self.entry_3_z1.configure(state=c3)
        self.entry_3_z3.configure(state=c3)
        self.entry_3_z2.configure(state=c3)
        self.label_3_x.configure(state=c3)
        self.entry_3_x1.configure(state=c3)
        self.entry_3_x3.configure(state=c3)
        self.entry_3_x2.configure(state=c3)
        self.label_3_b.configure(state=c3)
        self.entry_3_b1.configure(state=c3)
        self.entry_3_b3.configure(state=c3)
        self.entry_3_b2.configure(state=c3)
        self.label_3_IT.configure(state=c3)
        self.combo_3_IT1.configure(state=c3)
        self.combo_3_IT3.configure(state=c3)
        self.combo_3_IT2.configure(state=c3)
        
        self.radio_3_Eb1.configure(state=c3)
        self.radio_3_Eb3.configure(state=c3)
        self.radio_3_Eb2.configure(state=c3)
        self.radio_3_Ey1.configure(state=c3)
        self.radio_3_Ey3.configure(state=c3)
        self.radio_3_Ey2.configure(state=c3)
        self.label_3_Eb.configure(state=c3)
        self.label_3_Ebs.configure(state=c3)
        self.label_3_Ebi.configure(state=c3)
        self.label_3_Eb_K.configure(state=c3)
        self.label_3_Ey_Dm.configure(state=c3)
        self.entry_3_Ebs1.configure(state=c3)
        self.entry_3_Ebs3.configure(state=c3)
        self.entry_3_Ebs2.configure(state=c3)
        self.entry_3_Ebi1.configure(state=c3)
        self.entry_3_Ebi3.configure(state=c3)
        self.entry_3_Ebi2.configure(state=c3)
        self.entry_3_Eb_K1.configure(state=c3)
        self.entry_3_Eb_K3.configure(state=c3)
        self.entry_3_Eb_K2.configure(state=c3)
        self.entry_3_Ey_Dm1.configure(state=c3)
        self.entry_3_Ey_Dm3.configure(state=c3)
        self.entry_3_Ey_Dm2.configure(state=c3)

        if c3=='normal':
            self.checkfun_3_x1()
            self.radiofun_3_EbEy()
            
            
            
    '''
    def checkfun_FrFi(self):
        cFrFi = self.check_FrFi_var.get()
        self.radio_Fr.configure(state=cFrFi)
        self.radio_Fi.configure(state=cFrFi)
        if cFrFi=='normal':
            pass
    '''
    
    def radiofun_1_EbEy(self):
        [self.Eb_1_var1,self.Ey_1_var1] = ['normal','disable'] if self.radio_1_EbEy1_var.get()=='Eb' else ['disable','normal']
        [self.Eb_1_var3,self.Ey_1_var3] = ['normal','disable'] if self.radio_1_EbEy3_var.get()=='Eb' else ['disable','normal']
        [self.Eb_1_var2,self.Ey_1_var2] = ['normal','disable'] if self.radio_1_EbEy2_var.get()=='Eb' else ['disable','normal']
        
        self.entry_1_Eb_K1.configure(state=self.Eb_1_var1)
        self.entry_1_Eb_K3.configure(state=self.Eb_1_var3)
        self.entry_1_Eb_K2.configure(state=self.Eb_1_var2)
        
        self.entry_1_Ey_Dm1.configure(state=self.Ey_1_var1)
        self.entry_1_Ey_Dm3.configure(state=self.Ey_1_var3)
        self.entry_1_Ey_Dm2.configure(state=self.Ey_1_var2)
        
    def radiofun_2_EbEy(self):
        [self.Eb_2_var1,self.Ey_2_var1] = ['normal','disable'] if self.radio_2_EbEy1_var.get()=='Eb' else ['disable','normal']
        [self.Eb_2_var3,self.Ey_2_var3] = ['normal','disable'] if self.radio_2_EbEy3_var.get()=='Eb' else ['disable','normal']
        [self.Eb_2_var2,self.Ey_2_var2] = ['normal','disable'] if self.radio_2_EbEy2_var.get()=='Eb' else ['disable','normal']
        
        self.entry_2_Eb_K1.configure(state=self.Eb_2_var1)
        self.entry_2_Eb_K3.configure(state=self.Eb_2_var3)
        self.entry_2_Eb_K2.configure(state=self.Eb_2_var2)
    
        self.entry_2_Ey_Dm1.configure(state=self.Ey_2_var1)
        self.entry_2_Ey_Dm3.configure(state=self.Ey_2_var3)
        self.entry_2_Ey_Dm2.configure(state=self.Ey_2_var2)
    
    def radiofun_3_EbEy(self):
        [self.Eb_3_var1,self.Ey_3_var1] = ['normal','disable'] if self.radio_3_EbEy1_var.get()=='Eb' else ['disable','normal']
        [self.Eb_3_var3,self.Ey_3_var3] = ['normal','disable'] if self.radio_3_EbEy3_var.get()=='Eb' else ['disable','normal']
        [self.Eb_3_var2,self.Ey_3_var2] = ['normal','disable'] if self.radio_3_EbEy2_var.get()=='Eb' else ['disable','normal']
        
        self.entry_3_Eb_K1.configure(state=self.Eb_3_var1)
        self.entry_3_Eb_K3.configure(state=self.Eb_3_var3)
        self.entry_3_Eb_K2.configure(state=self.Eb_3_var2)
        
        self.entry_3_Ey_Dm1.configure(state=self.Ey_3_var1)
        self.entry_3_Ey_Dm3.configure(state=self.Ey_3_var3)
        self.entry_3_Ey_Dm2.configure(state=self.Ey_3_var2)
    
    def calcx1(self,x2, x3, z1, z3, z2, alpha=radians(20)):  # 根据x2,x3，计算两个啮合角，最后计算出x1
        z_segma_13 = z1+z3
        z_segma_32 = z2-z3
        x_segma_32 = x2-x3
        alpha_work_32 = inv_1(
            x_segma_32*2*tan(alpha)/z_segma_32+inv(alpha))
        alpha_work_13 = acos(
            z_segma_13/z_segma_32*cos(alpha_work_32))
        x_segma_13 = z_segma_13 * \
            (inv(alpha_work_13)-inv(alpha))/(2*tan(alpha))
        x1 = x_segma_13 - x3
        return x1
    
if __name__ == '__main__':
    root = Tk()
    gui = GearGUI_hc(root)
    root.mainloop()